export default {
    exp:/\((.+?)\)/g,
    /**
     * 
     * @param {if判断的条件字符串} String ifValue 
     * @param {数据} Object data 
     */
    init:function(ifValue,data){
        //如果没有表达式 返回false
        if(!ifValue) {
            return false;
        }
        //匹配带括号的数组
        var  kuohao = this.regex(ifValue);
        if(kuohao) {
            //把原字符串中带括号的 全部替换为空
            ifValue = ifValue.replace(this.exp,'');
        }
     
        //如果是或者表达式
        if(ifValue.indexOf('||') != -1) {
            //如果括号外的条件为否，继续判断括号内的条件 如果为真 直接返回true
            if(this.orExpression(ifValue,data) === true){
                return true;
            }

            //开始解析括号内条件
            for(var i in kuohao) {
                var newStr = kuohao[i].substring(1,kuohao[i].length-1);
                if(newStr.indexOf('||') != -1) {
                    if(this.orExpression(newStr,data) == true) {
                        return true;
                    }
                    continue;
                }else if(newStr.indexOf('&&') != -1){
                    if(this.andExpression(newStr,data) === true) {
                        return true;
                    }
                    continue;
                }
            }
            
            
        }
        //如果是并且表达式
        else if(ifValue.indexOf('&&') != -1) {
            if(this.andExpression(ifValue,data) === false){
                return false;
            }

             //开始解析括号内条件
             for(var i in kuohao) {
                var newStr = kuohao[i].substring(1,kuohao[i].length-1);
                if(newStr.indexOf('||') != -1) {
                    if(this.orExpression(newStr,data) == false) {
                        return false;
                    }
                    continue;
                }else if(newStr.indexOf('&&') != -1){
                    if(this.andExpression(newStr,data) === false) {
                        return false;
                    }
                    continue;
                }
            }

            return true;
        }
        //如果是单个表达式
        else{
           return this.expression(ifValue,data);
        }

        return false;

    },
    //匹配括号中的内容
    regex:function(str){
       var result = str.match(this.exp);
       return result;
    },
    //并且表达式解析
    andExpression:function(ifValue,data){
        var andIfValue = ifValue.split('&&');
        var arr= andIfValue.filter(function (el) {
            return el !== '';
        });

        var ifReturn = true;
        
        for(var i in arr) {
            if(this.expression(arr[i],data) === false) {
                ifReturn = false;
                break;
            }
        }

        return ifReturn;

    },
    //或者表达式解析
    orExpression:function(ifValue,data){
        var orIfValue = ifValue.split('||');
        var arr= orIfValue.filter(function (el) {
            return el !== '';
        });
        var ifReturn = false;

        for(var i in arr) {
            if(this.expression(arr[i],data) === true) {
                ifReturn = true;
                break;
            }
        }

        return ifReturn;

    },
    //表达式解析
    expression:function(str,data){
        if(!data || JSON.stringify(data) == '{}' || typeof data != 'object') {
            return false;
        }

        if(str.indexOf('>') != -1) {
           var arr = str.split('>');
           if(arr.length < 2) {
                return false;
           }
           if(data[arr[0]] === undefined) {
                return false;
           }

           return this.gt(data[arr[0]],arr[1]);

        }else if(str.indexOf('==') != -1) {
            var arr = str.split('==');
           
            if(arr.length < 2) {
                 return false;
            }
           
            if(data[arr[0]] === undefined) {
                 return false;
            }
 
            return this.eg(data[arr[0]],arr[1]);

        }else if(str.indexOf('=') != -1) {
            var arr = str.split('=');
           
            if(arr.length < 2) {
                return false;
            }
           
            if(data[arr[0]] === undefined) {
                 return false;
            }
 
            return this.eg(data[arr[0]],arr[1]);

        }else if(str.indexOf('<') != -1) {
            var arr = str.split('<');
            if(arr.length < 2) {
                 return false;
            }
            if(data[arr[0]] === undefined) {
                 return false;
            }
 
            return this.lt(data[arr[0]],arr[1]);
        }else if(str.indexOf('>=') != -1) {
            var arr = str.split('>=');
            if(arr.length < 2) {
                 return false;
            }
            if(data[arr[0]] === undefined) {
                 return false;
            }
 
            return this.egt(data[arr[0]],arr[1]);

        }else if(str.indexOf('<=') != -1) {
            var arr = str.split('<=');
            if(arr.length < 2) {
                 return false;
            }
            if(data[arr[0]] === undefined) {
                 return false;
            }
 
            return this.elt(data[arr[0]],arr[1]);
        }

        return false;
    },
    gt:function(ifStr,valstr){
        //大于
        if(ifStr+'' > valstr+'') {
            return true;
        }

        return false;
    },
    lt:function(ifStr,valstr){
        //小于
        if(ifStr+'' < valstr+'') {
            return true;
        }

        return false;
    },
    eg:function(ifStr,valstr){
        //等于
        if(ifStr+'' == valstr+'') {
            return true;
        }

        return false;
    },
    egt:function(ifStr,valstr){
        //大于等于
        if(ifStr+'' >= valstr+'') {
            return true;
        }

        return false;
    },
    elt:function(ifStr,valstr){
        //小于等于
        if(ifStr+'' <= valstr+'') {
            return true;
        }

        return false;
    }
}